rochars / byte-data

 * bit-packer: Pack and unpack nibbles, crumbs and booleans into bytes.

 * Copyright (c) 2017 Rafael da Silva Rocha.

 * https://github.com/rochars/byte-data

 */

let pad = require("../src/byte-padding.js");

/**

 * Pack 2 nibbles in 1 byte.

 * @param {!Array<number>} nibbles Array of nibbles.

 * @return {!Array<number>} Pairs of neebles packed as one byte.

 */

function packNibbles(nibbles) {

    let packed = [];

    let i = 0;

    let j = 0;

    let len = nibbles.length;

    if (len % 2) {

        nibbles.push(0);

    }

    while (i < len) {

        packed[j++] = parseInt(

            nibbles[i].toString(16) + nibbles[i+1].toString(16), 16);

        i+=2;

    }

    return packed;

}

/**

 * Unpack a byte into 2 nibbles.

 * @param {!Array<number>|Uint8Array} bytes Array of bytes.

 * @return {!Array<number>} The nibbles.

 */

function unpackNibbles(bytes) {

    let unpacked = [];

    let i = 0;

    let j = 0;

    let len = bytes.length;

    while (i < len) {

        unpacked[j++] = parseInt(bytes[i].toString(16)[0], 16);

        unpacked[j++] = parseInt(bytes[i].toString(16)[1], 16);

        i++;

    }

    return unpacked;

}

/**

 * Pack 4 crumbs in 1 byte.

 * @param {!Array<number>} crumbs Array of crumbs.

 * @return {!Array<number>} 4 crumbs packed as one byte.

 */

function packCrumbs(crumbs) {

    let packed = [];

    let i = 0;

    let j = 0;

    pad.fixByteArraySize(crumbs, 4);

    let len = crumbs.length - 3;

    while (i < len) {

        packed[j++] = parseInt(

            pad.lPadZeros(crumbs[i].toString(2), 2) +

            pad.lPadZeros(crumbs[i+1].toString(2), 2) +

            pad.lPadZeros(crumbs[i+2].toString(2), 2) +

            pad.lPadZeros(crumbs[i+3].toString(2), 2), 2);

        i+=4;

    }

    return packed;

}

/**

 * Unpack a byte into 4 crumbs.

 * @param {!Array<number>|Uint8Array} crumbs Array of bytes.

 * @return {!Array<number>} The crumbs.

 */

function unpackCrumbs(crumbs) {

    let unpacked = [];

    let i = 0;

    let j = 0;

    let len = crumbs.length;

    let bitCrumb;

    while (i < len) {

        bitCrumb = pad.lPadZeros(crumbs[i].toString(2), 8);

        unpacked[j++] = parseInt(bitCrumb[0] + bitCrumb[1], 2);

        unpacked[j++] = parseInt(bitCrumb[2] + bitCrumb[3], 2);

        unpacked[j++] = parseInt(bitCrumb[4] + bitCrumb[5], 2);

        unpacked[j++] = parseInt(bitCrumb[6] + bitCrumb[7], 2);

        i++;

    }

    return unpacked;

}

/**

 * Pack 8 booleans in 1 byte.

 * @param {!Array<number>} booleans Array of booleans.

 * @return {!Array<number>} 4 crumbs packed as one byte.

 */

function packBooleans(booleans) {

    let packed = [];

    let i = 0;

    let j = 0;

    pad.fixByteArraySize(booleans, 8);

    let len = booleans.length - 7;

    while (i < len) {

        packed[j++] = parseInt(

            booleans[i].toString(2) +

            booleans[i+1].toString(2) +

            booleans[i+2].toString(2) +

            booleans[i+3].toString(2) +

            booleans[i+4].toString(2) +

            booleans[i+5].toString(2) +

            booleans[i+6].toString(2) +

            booleans[i+7].toString(2), 2);

        i+=8;

    }

    return packed;

}

/**

 * Unpack a byte into 8 booleans.

 * @param {!Array<number>|Uint8Array} booleans Array of bytes.

 * @return {!Array<number>} The booleans.

 */

function unpackBooleans(booleans) {

    let unpacked = [];

    let i = 0;

    let j = 0;

    let len = booleans.length;

    let bitBoolean;

    while (i < len) {

        bitBoolean = pad.lPadZeros(booleans[i].toString(2), 8);

        unpacked[j++] = parseInt(bitBoolean[0], 2);

        unpacked[j++] = parseInt(bitBoolean[1], 2);

        unpacked[j++] = parseInt(bitBoolean[2], 2);

        unpacked[j++] = parseInt(bitBoolean[3], 2);

        unpacked[j++] = parseInt(bitBoolean[4], 2);

        unpacked[j++] = parseInt(bitBoolean[5], 2);

        unpacked[j++] = parseInt(bitBoolean[6], 2);

        unpacked[j++] = parseInt(bitBoolean[7], 2);

        i++;

    }

    return unpacked;

}

module.exports.packBooleans = packBooleans;

module.exports.unpackBooleans = unpackBooleans;

module.exports.packCrumbs = packCrumbs;

module.exports.unpackCrumbs = unpackCrumbs;

module.exports.packNibbles = packNibbles;